Method and apparatus for semantic discovery and mapping between data sources

ABSTRACT

An apparatus and method are described for the discovery of semantics, relationships and mappings between data in different software applications, databases, files, reports, messages, or systems. In one aspect, semantics and relationships and mappings are identified between a first and a second data source. A binding condition is discovered between portions of data in the first and the second data source. The binding condition is used to discover correlations between portions of data in the first and the second data source. The binding condition and the correlations are used to discover a transformation function between portions of data in the first and the second data source.

RELATED APPLICATIONS

This application is related to and claims the benefit of U.S. Provisional Patent Application 60/502,043 entitled “A METHOD AND APPARATUS FOR SEMANTIC DISCOVERY AND MAPPING BETWEEN DATA SOURCES,” filed Sep. 10, 2003, which is herein incorporated by reference.

TECHNICAL FIELD

The present invention relates to a method and apparatus for automating the way computer systems, applications, files and databases are integrated. Specifically, the present invention relates to the discovery of semantics, relationships and mappings between data in different software applications, databases, files, reports, messages or systems.

DESCRIPTION OF RELATED ART

The Information Technology (IT) professionals have performed data and application integration for many years. A typical integration project has three distinct phases: discovery, integration, and maintenance. Discovery phase involves identifying relationships between the systems that need to be integrated. Integration phase involves creating programs or specifications to perform the physical data movement or interfacing. The maintenance phase involves updating and changing the integration programs to correspond to changes in the systems being integrated or to accommodate new integration requirements.

Several prior art patents describe various conventional ways of integrating data across systems. U.S. Pat. No. 05,675,785—Hall, et al., Oct. 10, 1997, 395/613, “DATA WAREHOUSE WHICH IS ACCESSED BY A USER USING A SCHEMA OF VERTICAL TABLES”. This patent describes a system where a layer of logical tables is created and mapped to the physical tables in a data warehouse such that the user specifies queries against the logical tables to access data in the physical tables. It does not address the problem of discovering relationships and mappings between data in different data sources.

U.S. Pat. No. 05,806,066—Golshani et al, Sep. 8, 1998, 707/100, “METHOD OF INTEGRATING SCHEMAS OF DISTRIBUTED HETEROGENEOUS DATABASES”. This patent describes a graphical system that allows the user to graphically merge multiple distributed schemas into a global schema. It does not address the use of data to determine the relationship between the two schemas.

U.S. Pat. No. 05,809,297 Kroenke, et al Sep. 15, 1998, 395/613, “SEMANTIC OBJECT MODELING SYSTEM FOR CREATING RELATIONAL DATABASE SCHEMAS”. This patent describes how to create a relational schema from a semantic object definition.

U.S. Pat. No. 06,026,392 Kouchi et al. Feb. 15, 2000, 707/200, “DATA RETRIEVAL METHOD AND APPARATUS WITH MULTIPLE SOURCE CAPABILITY”. This patent describes a system that moves data from source database to target database with a different structure. However, the '392 patent does not describe creating a new data source based on the structure of an existing data source, or moving data from the existing data source to the new one, or creating reports from the new data source.

U.S. Pat. No. 06,226,649 Bodamer, et al. May 1, 2001, 707/104, “APPARATUS AND METHOD FOR TRANSPARENT ACCESS OF FOREIGN DATABASES IN A HETEROGENEOUS DATABASE SYSTEM”. This patent addresses remote access of data from a heterogeneous database. The '649 patent does not address the determination of how that remote data is related to the data in the local database.

U.S. Pat. No. 06,339,775 Zamanian et al. Jan. 15, 2002 707/101, “APPARATUS AND METHOD FOR PERFORMING DATA TRANSFORMATIONS IN DATA WAREHOUSING”. This patent describes a system and apparatus that extracts, transforms and loads data from one or more data sources to a data warehouse.

U.S. Pat. No. 06,393,424 Hallman et al, May 21, 2002, 707/10, “METHOD AND APPARATUS FOR USING A STATIC METADATA OBJECT TO REDUCE DATABASE ACCESS”. This patent describes a system that retrieves metadata from memory and uses it to retrieve data from the database. This patent applies to a single database access, not a relationship between data in different databases or different data tables in the same database.

U.S. Pat. No. 20020178170A1 Britton, et al, Nov. 28, 2002, 707/100, “METHOD AND APPARATUS FOR ENTERPRISE APPLICATION INTEGRATION”. This patent addresses heterogeneous data access, not the relationship between heterogeneous data.

WO 01/75679 A1 Scanlon et al. Oct. 11, 2001, G06F 17/30, “A SYSTEM AND METHOD FOR ACCESSING DATA IN DISPARATE INFORMATION SOURCES”

WO 02/073468 A1—Kil, et al., Sep. 19, 2002, G06F 17/30, “AUTOMATIC DATA EXPLORER THAT DETERMINES RELATIONSHIPS BETWEEN ORIGINAL AND DERIVED FIELDS”

The integration phase has been the focus for computer scientists and software vendors for many years. The discovery phase, however, has not been automated and frequently involves a time-consuming manual and cross-functional effort.

SUMMARY OF THE INVENTION

Embodiments of the present invention are directed to data analysis and automatic determination of causal relationships and correlations between various data fields in order to improve the performance of a data analysis process. The discovery of semantics, relationships and mappings between data in different software applications, databases, files, reports, messages, or systems, is described. In one aspect, semantics and relationships and mappings are identified between a first and a second data source. A binding condition is discovered between portions of data in the first and the second data source. The binding condition is used to discover correlations between portions of data in the first and the second data source. The binding condition and the correlations are used to discover a transformation function between portions of data in the first and the second data source.

Other features of the present invention will be apparent from the accompanying drawings and from the detailed description which follows.

DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example and not limitation in the figures of the accompanying drawings, in which:

FIG. 1 illustrates a flow chart of an embodiment of a Simple Automatic Mapping process

FIG. 2 illustrates a flow chart of an embodiment of a Binding Condition Validation process.

FIG. 3 illustrates a flow chart of an embodiment of a Complete Mapping Discovery process.

FIG. 4 illustrates a flow chart of an embodiment of an Equality Based Binding Condition Discovery process.

FIG. 5 illustrates a flow chart of an embodiment of a Construct Binding Condition process.

FIG. 6 illustrates a flow chart of an embodiment of a Positional Transformation Discovery process.

FIGS. 7A, 7B and 7C illustrate embodiments of a graphical user interface of the present invention.

FIG. 8 illustrates an embodiment of a computer system on which the present invention may be implemented.

DETAILED DESCRIPTION

An apparatus and method is described for the discovery of semantics, relationships and mappings between data in different software applications, databases, files, reports, messages or systems. In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be evident however to one of ordinary skill in the art that the present invention may be practiced without these specific details. In other instances, well known structures and devices are shown in blocked diagram form in order to avoid unnecessarily obscuring the present invention.

Reference throughout this specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, the appearances of the phrases “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

In one embodiment, steps according to the present invention are embodied in machine-executable software instructions, and the present invention is carried out a processing system by a processor executing the instructions, as will be described in greater detail below. In other embodiments, hardwired circuitry may be used in place of, or in combination with, software instructions to implement the present invention.

I. Overview

Embodiments of the present invention automate the discovery of semantics, relationships and mappings between data in disparate software applications, databases, files, reports, messages or systems. The metadata and the data in the systems are analyzed using a set of rules, techniques and statistics to deduce relationships between the systems.

The schema in the disparate system is converted into a normalized relational model. Normalized schemas are converted into data objects—objects with a key and scalar and non-scalar attributes. Metadata and data analysis is used to discover a binding condition that relates the data objects instances across systems. Binding condition is a Boolean expression on attributes of the data objects from one or more source systems and a target system that identifies which instances of the source data objects map to which instances of the target data object. The object instances thus related through the binding condition are said to be bound. Bound object instances are then analyzed to establish attribute correlation. Finally, transformation discovery is applied to correlated attributes (columns) to discover transformation functions. Conversely, attributes are used to establish binding in the first place.

As will be described in more detail below, an embodiment of the present invention includes three main processes that contribute to the automated discovery and mapping system. The first process discovers the binding condition between tables in disparate systems. The second process uses an established binding condition to discover correlations between the columns of the bound tables. The third process uses an established binding condition and correlation to discover transformation functions between correlated columns of bound tables.

For simplicity of description, all processes assume one source table and one target table. However, the processes can be applied to multiple source tables by treating such tables as a single view that represents a join of such source tables. In one embodiment, tables include relational tables or tabular files.

Also for simplicity of description, all processes assume that all source and target tables can be copied in their entirety to a single relational database. More practical implementations involve the use of intelligent sampling that only uses related portions of the source and target tables. Alternatively, federated databases, distributed queries or data Extraction, Transformation and Loading (ETL) tools may also be used to join tables across databases.

A. Assumptions and Observations

In an embodiment of the present invention, the following assumptions and observations apply.

All data in a conventional business enterprise is related one way or another—it is mostly a matter of discovering the relationship.

It is possible to use data to identify relationships between data tables.

Except for several well-understood design patterns (e.g., timestamps, counters, generated keys), accidental correlation between different data sources is highly unlikely in large data sets.

B. Key Concepts

Key concepts relating to embodiments of the present invention are described below.

Data Objects—All the key business entities in the enterprise can be represented as a set of data objects. The relationship between these data objects captures the business rules and workings of an enterprise. Every piece of data in the enterprise belongs to one or more data objects. The data objects are present in every system of the enterprise. They can be persisted in the databases (e.g. Relational Database Management Systems (RDBMS) or files, exchanged as messages (e.g. Extensible Markup Language (XML) messages) and manipulated by the applications. Since all enterprises require history and persistence, all the data objects are persisted (stored) somewhere in the enterprise. Because the data objects represent the enterprise, all the data sources in the enterprise are related to each other through the data objects.

Furthermore, all the systems in the enterprise have to work together irrespective of whether they are integrated through automated means (machine to machine) or through intermediate human processes or both. We know they do because orders get accepted, goods get manufactured, orders get filled, services provided, financial information reported and taxes paid. While there may be gaps in the data chains because of purely manual processes and record keeping—it is uncommon for any sizable enterprise that any major system is not automated—links and business processes between systems can be manual, but the systems themselves are normally computerized.

Data objects can be identified and normalized through key discovery, primary-foreign key dependency discovery and join key discovery.

Data objects are represented as a set of parent-child tables where the child has a foreign key from the parent. Data Object is an acyclical graph (a tree). Data object has one and only one root table. Data object can be represented as an outer join of every parent and every child without any loss of data.

Source Data Objects (SDO)—Source Data Objects are data objects discovered in a single data source.

Universal Data Objects or Global Data Objects (UDO)—Universal Data Objects or Global Data Objects are data objects that are persisted in multiple data sources. UDOs are mapped to one or more SDOs.

Binding—Binding is a way to identify the same instance of a UDO across one or more SDOs. For example, if we have a Customer Universal Data Object and a set of Customer Source Data Objects mapped to the Customer UDO, there is a binding condition for each SDO that identifies the same instance of the data object (i.e., the same physical customer) between that SDO and the Customer UDO.

UDO to SDO binding—Binding is always discovered or specified between a UDO and an SDO.

SDO to SDO binding—Using transitive closure, we can generate a binding condition between two or more SDOs using the binding conditions between each SDO and UDO. Sometimes, there may not be a direct binding condition between two SDOs and additional SDOs linking the original two need to be included. For example, there may be a lookup table in Source1 that links together customer ids in Source2 with customer ids in Source3. A binding condition between Source2 and Source3 will have to include Source1 and the lookup table.

Binding is essentially a join condition—Binding is a federated, full outer join condition—a full outer join between tables in two or more data sources. We assume that a majority of the binding conditions are equijoins between table keys.

Correlation—Correlation is a way to discover binding conditions. Correlation is a way to identify data attributes that represent the same values a different way. For example, one system may represent sales regions as North, South, East and West and another as 1, 2, 3 and 4. However, for the same instance of a data object such as customer, the region in one system would correspond to a region in the other system—e.g., North would correspond to 1,South to 2,etc.

Most of the time, we do not have to know what the transformation function is to detect correlation. Given a scalar, stateless transformation function f that can transform a value V1 in System1 into a value V2 in System2 (V2=f(V1)), for the same instance of a data object in System 1 and System 2, if the same value V1 i in system 1 always corresponds the same value of V2 i in System 2, there is a correlation between the two. There are transformation functions that do not produce correlations detectable by value correspondence. These include Aggregate functions.

There may be false correlations. These are usually based on generated keys such as integer counters, timestamps, etc. However, these are typically out of sync and do not detect any other correlations and are therefore not picked as binding conditions.

Because we use statistics and attempt to find the best rather than absolute match, we can work with dirty or incomplete information and do not have to identify all possible binding conditions.

Correlations can be between a single column in one data object and one or more columns in another data object. Because transformation functions are scalar, the target has to be a single column.

We assume that a binding condition will have the highest number of attribute correlations between an SDO and a UDO. Thus, we can look at potential binding conditions and see which one gives us the highest number of correlations.

Value Matching—Value matching is a matching of values in two attributes or columns. Value Matching returns statistics about how many values in one column have matches in another column. In one embodiment, matching is performed by comparison of values. In other embodiments, faster comparison techniques may be used to match values, such as hashing or other compression techniques. For example, in one embodiment, matching is performed by comparing values derived from original values, such as would result from comparing hash values of the original values.

Bound Matching, Transformation Function Discovery—using a binding condition and correlation between a set of source columns and target columns, try to identify the transformation function that converts source column values into the target column value.

C. Approach

In one embodiment, given a data source and a set of universal data objects UDOs, the source is mapped to UDOs, using the following approach:

-   -   1. Identify local data objects at the source (SDOs)         -   1.1. Use key analysis to identify keys         -   1.2. Use foreign key and join key discovery to identify             relationship between tables         -   1.3. Build trees of tables             -   1.3.1. Remove cycles         -   1.4. Convert each tree into a source data object SDO     -   2. Determine binding conditions between UDOs and SDOs         -   2.1. Perform Value Matching         -   2.2. Determine correlations between data sources through             data analysis and statistics         -   2.3. Identify binding condition with the highest correlation     -   3. Match instances of data objects across data sources using         bound matching         -   3.1. Apply binding condition between a UDO and SDO         -   3.2. Look at correlated columns         -   3.3. Apply transformation functions to see if can get target             value from source values.     -   4. Add unmapped SDO attributes to the UDO         -   4.1 Starting with table ST that is the root of SDO and table             UT that is bound to ST             -   4.1.1 If any attribute of ST is unmapped, add it to UT             -   4.1.2 If any child table SCT of ST does not have a                 binding condition with some table UT′ in UDO, add table                 SCT as a child of table UT in UDO.         -   4.2 Repeat for every child of ST

II. Simple Automatic Mapping

A. Overview

The following simplest method, although not practical for large-scale deployments, captures the essence of the approach and illustrates embodiments of the techniques that will be used in more complex approaches.

Given:

-   -   a. Two data sources: Source S and Target T with tables: Ts1 . .         . Tsi and Tt1 . . . Ttj respectively, where each table has         columns Ct1 . . . Ctn where t is the table number (e.g., CS11 .         . . CS1n)     -   b. A set of Value Match Rules (VMR) that can take 2 input tables         and determine how many rows in one table match the rows in the         other table. The rules can be as simple as equality (that         determines if the values in two columns are identical) or very         complex. Every VMR returns the following statistics:         -   i. Number of rows in Target table that had matches,         -   ii. Number of distinct values in Target table that had one             or more matches.         -   iii. Number of distinct values in Target tables that had 1             or more mismatches.

Given the above, the Simple Automatic Mapping method discovers mappings between the columns, tables and data sources. FIG. 1 illustrates an embodiment of a Simple Automatic Mapping process 100. At block 102, the process 100 determines value match scores. At block 104, the process 100 discovers binding conditions by determining correlation scores, i.e. does the same value of S correspond to the same value of T. At block 106, the process 100 discovers transformation functions (i.e. attribute matches) by examining correlated source and target columns. At block 108, the process discovers filters, i.e. horizontal partitions of the table where a given binding condition or mapping is strong.

B. Simple Automatic Mapping Process

The Simple Automatic Mapping process 100 illustrated in FIG. 1 is described below in greater detail. In the following description, we will refer to a UDO as a target and an SDO as a source.

The processing represented by block 102 of FIG. 1 identifies potential binding condition columns. For each target attribute and a set of source attributes, Value Match Scores are determined by applying every VMR to every set of source columns and creating a list of statistics for each VMR. The processing may be represented by the following pseudocode:

For each target attribute TAi For each set of source attributes (SA1, . . . , SAn) For every Value Mapping Rule VMRx Apply VMRx(SA1, . . . SAn) If the matching row count > Row Number Match Threshold (e.g., 20%), Store scores in a Value Match Table (VMT). The columns with entries in the VMT are the potential binding condition predicates.

The processing represented by block 104 of FIG. 1 validates Binding Conditions using correlations. FIG. 2 illustrates a flow chart of an embodiment of a Binding Condition Validation process 200, which may be performed at block 104 of FIG. 1. At block 202, the process 200 makes a list of potential binding conditions by creating every permutation of the binding condition predicates in the VMT. For every potential binding condition BCi, processing represented by blocks 206-220 is performed. The processing represented by block 206 constructs a binding condition expression BCEi. For every binding predicate BPj with target attribute TAj, Value Match Rule VMRj and source attributes SAj1 . . . SAjn, a predicate expression of the form TAj=VMRj(SAj1, . . . , SAjN) is created. A conjunction of all the predicates: TA1=VMR1(SA11, . . . , SA1N) and TA2=VMR2(SA21, . . . , SA2M) and . . . is subsequently created.

The processing represented by block 208 creates a view of the rows that match the binding condition expression. In other words, SourceBoundView=select*from Source where exists (select*from Target where BCi) and TargetBoundView=select*from Target where exists (select*from Source where BCi).

Optionally, in one embodiment, the processing represented by block 210 removes all unique columns or columns with no data (e.g., all NULL). Selectivity=#unique values/#rows—e.g., a unique key will have a selectivity of 1, a gender column−2/#rows. In one embodiment, the processing represented by block 210 filters out the columns with selectivity=0 or selectivity=1,as they will not give meaningful correlation.

At block 212, the process 200 creates a list of all possible combinations of SourceBoundView columns that are not part of the binding condition (Csi+1 . . . CSn): {Csi+1}, {Csi+1, Csi+2}, . . . , {Csi+1, . . . , CSn}). At block 214, the process 200 creates a list of all possible combinations of TargetBoundView columns that are not used by the binding condition (e.g., if binding condition is A.X=B.Y, all columns except A.X and B.Y are used).

At block 216, the process 200 determines correlation score between every combination of source and target columns where Selectivity Ratio is>SelectivityRatioThreshold (i.e., selectivity(source columns)/selectivity(target columns)>SelectivityRatioThreshold (e.g., 10)). Correlation score indicates whether the same value of the source combination corresponds to the same value of the target combination. Note that the values do not have to be the same, as long as the same value of source columns (e.g., A) always corresponds to the same value of target columns (e.g., B). Correlation Score=(% target rows where correlation holds)*selectivity of target columns. In one embodiment, determining the correlation can performed according to the following pseudo code:

For each source column, for each distinct value (CurrentSourceValue) Create a view ValView as select * from Target where exists (select * from source where BindingCondition and SourceColumn = CurrentSourceValue) For each target column Select count (TargetColumn) from ValView group by TargetColumn Choose the group with highest count, add it to the CorrelationRowCount At this point CorrelationRowCount contains the count of rows that are correlated. % rows where correlation holds=CorrelationRowCount/Target Row Count.

At block 218, the process 200 adds all correlation scores for each binding condition. At decision block 222, the process 200 determines whether the highest correlation score is less than a CorrelationThreshold. In one embodiment, the CorrelationThreshold is about 0.6. If it is determined at block 222 that the highest correlation score<CorrelationThreshold (e.g., 0.6), then at block 224, there is no binding between the tables. Otherwise, the processing represented by block 226 chooses the binding condition with highest correlation score sum. The correlation score sum is determined by summing the highest correlation score for each target column. The Binding Condition with the highest correlation score sum is chosen as the Primary Binding Condition and the remaining binding conditions are saved as Alternative Binding Conditions.

Referring again to FIG. 1, the processing represented by block 106 of FIG. 1 discovers Transformation Functions. For each pair of columns with correlation score>CorrelationThreshold, Transformation Rules (TR) are applied to determine if a transformation function can be deduced. All TRs with value match score>TransformationMatchThreshold as alternate mappings and the TR with highest value match score as the primary mapping. In one embodiment, the TransformationMatchThreshold is about 80%.

The processing represented by block 108 of FIG. 1 discovers filters. Very accurate mappings may be obtained if the data set is restricted. Given a binding condition and a TR, the processing represented by block 108 goes through every source column and identifies all columns where if a column C has a set of unique values V1 . . . Vn, some of the values V1 . . . Vi only occur in rows that match the binding condition and the mapping and other values Vi+1. . . Vn only occur in rows that do not match the binding condition. In one embodiment, the matching requirement may be relaxed, such that percentage of filter mismatches<FilterThreshold (e.g., 90%), to account for dirty data.

In one embodiment, the processing represented by block 108 generates a filter condition from the value list as follows:

-   -   Set VmaxMatch to the maximum value among the matching values for         column C.     -   If VmaxMatch=max(V1, . . . , Vi) is less than the minimum value         among the non-matching values VminMismatch=min(Vi+1, Vn),         generate the filter of the form C<VminMismatch     -   Else if VminMatch>VmaxMismatch, generate filter of the form         C>VmaxMismatch     -   Else if all matching rows have value V and non-matching rows         have values !=V, generate a filter of the form C=V     -   Else if all non-matching rows have value V and all matching rows         have values !=V, generate a filter of the form C !=V     -   Else if there is a small number of values that match the         condition, generate a filter condition of the form C in (V1, . .         . , Vn)     -   Else, if there is a small number of values that do not match the         condition, generate a filter condition of the form C not in         (Vi+1, . . . , Vn)

If the processing represented by block 108 discovers a filter for a table, a view on the source table is created as “select*from Source where not(FilterCondition)” and process as a separate table.

III. Complete Mapping Discovery

Complete Mapping Discovery is more elaborate than the Simple Automatic Mapping process, and may be used to improve performance. Instead of performing a match between every pair of attributes, Complete Mapping Discovery identifies the attributes with the highest possibility of matching and then applies the match rules.

A. Overview

FIG. 3 illustrates an embodiment of a Complete Mapping Discovery process 300. The processing represented by block 302 performs Join Condition Discovery to discover which tables are related and how they are related. Initially, all keys are identified in each table. This helps to identify natural keys as well as generated primary keys. Subsequently, inclusion dependencies are also identified. For example, if table C has a foreign key (columns F1 . . . Fn) from P and any Fi is part of any key of C dicovered in the previous step, there is an inclusion dependency between C and P where P is the parent and C is the child.

The processing represented by block 304 generates Source Data Objects (SDOs) using join conditions. The process 300 builds an SDO tree. An SDO tree is a tree of tables joined by parent-child relationships discovered by the processing at block 302. In one embodiment, an SDO view as a full outer-join of all parents and children in the tree is also built by the processing represented by block 304. At block 306, the process 300 performs a Schema Matching process between source and target data objects to identify attributes with high potential of matching.

At block 308, the process 300 discovers binding conditions. The process 300 identifies tables that have potential matches and performs correlation analysis to identify groups of columns that have a high degree of correlation.

At block 310, the process 300 performs Transformation Discovery on attributes with high degree of correlation. At block 312, the process performs Filter Condition Discovery on Binding Condition and attributes with a high degree of correlation. In one embodiment, the processing represented by block 312 is the same as that represented by block 108, described above with respect to the Simple Automatic Mapping illustrated in FIG. 1.

B. Complete Mapping Discovery Process

The Complete Mapping Discovery process 300 illustrated in FIG. 3 is described below in greater detail.

1. Join Condition Discovery

Join Condition Discovery (JCD), performed at block 302, discovers which tables are related and how they are related. The first step in JCD is to identify all the keys in each table. The keys may be declared as primary keys, may be defined as unique indices or may have to be discovered by examining the data for column sets that would constitute a unique index. To illustrate an example of one embodiment, the Northwind sample database that is included with Microsoft® Access and Microsoft SQL Server™, available from Microsoft Corporation, Redmond, Washington, is used to illustrate the processes.

a. Key Discovery

In one embodiment, the JCD discovers unique keys by a Key Discovery process as follows:

If a table has a primary key consisting of columns P1, . . . , Pn, the Key Discovery process add it to the unique key set K, K={(P1, . . . , Pn)} Northwind.Suppliers.SupplierId

If there is a unique index for a table on columns I1, . . . , Im, the Key Discovery process adds the columns of the index to K as a key: K={(P1, . . . , Pn), (I1, . . . , Im)}

The Key Discovery process checks selectivity of every column. If the relation has R rows and a column Cn has V unique values, it's selectivity will be S=V/R. If selectivity is 1,then the column is unique—add it to K: K={(P1, . . . , Pn), (I1, . . . , Im), (Cn)}Northwind.Suppliers.CompanyName, ContactName, Address, PostalCode, Telephone

The Key Discovery process checks cardinality of all columns (C1, . . . , CnotInKCount) not in K already. Determine cardinality=select count distinct(C1 |. . . | CnotInKCount) from T. If cardinality (the count of distinct values of all column not in K)<R, there are no more unique keys in T. If cardinality is R, determine all minimal subsets that are unique as follows:

-   -   Given a set of columns C1, . . . , Cn with cardinality R, check         cardinality of subsets (C1, . . . , Cn-1); (C1, C3, . . . , Cn),         (C1, C2, C4, . . . , Cn) and so on.         -   If the cardinality of all subsets is less than R, then C1, .             . . , Cn is the minimal subset—add it to K.         -   Otherwise, repeat this exercise for each subset with             cardinality of R.

The cardinality of Northwind.Suppliers is 29. Cardinality(Suppliers.ContactTitle, Region, Country, Fax, HomePage)=29,but selectivity of any subset of the columns<29. Therefore, there is a unique key consisting of ContactTitle, Region, Country, Fax, HomePage.

b. Foreign Key Discovery

In one embodiment, JCD discovers foreign keys through data source metadata and through data-driven discovery. Foreign key discovery is performed by a Foreign Key Discovery process as follows.

The Foreign Key Discovery process performs a value match between every key column discovered in Key Discovery step of every table. If the hit percentage (#rows that match/#rows in a table) is >ForeignKeyThreshold for either table, then we say there is a potential foreign key dependency between the two systems on this column. In one embodiment, the ForeignKeyThreshold is about 90%.

The Foreign Key Discovery process then matches a full key from one table to a full or partial key in the other table. Partial keys are not matched to another partial key (e.g., Zip code in Customer will have a high match rate with Zip code in Suppliers), since neither is a key in itself and the match is meaningless unless a full key from either relation can be matched. For each key in Table 1,if every column in the key has a corresponding potential foreign key in Table 2,correlation analysis is performed to make sure that the columns in the same row in Table1, match the columns in the same row in Table 2. In one embodiment, if the correlation score is lower than about 80% of the smallest match score for individual columns, it is assumed that this is a false foreign key. After correlation analysis, there may still be multiple keys remaining. Correlation analysis is performed across different keys. If there is a match (e.g. >80% of minimum correlation), the keys are combined into a single foreign key. Otherwise, they are left as separate potential foreign keys.

Subsequently, the Foreign Key Discovery process determines which table is primary and which is foreign. If there is a primary-foreign key relationship between a full key of P, but only a partial key of C, then P is the parent and C is the child and the primary-foreign key relationship between them is said to be identifying. If the match columns include a full key of P and a full key of C, then P and C are peers and the relationship is said to be a partition relationship. Note that because multiple join keys may be discovered, the same two tables may have multiple instances of each type of relationships: Table 1 as parent, Table 2 as child; Table 2 as parent and Table 1 as child; and Table 1 and Table 2 as peers. Each relationship will have a different join key.

c. Inclusion Dependency Discovery

Inclusion dependencies are identified by JCD. If table C has a foreign key (columns F1 . . . Fn) from P and any Fi is part of any key of C discovered in previous step, there is an inclusion dependency between C and P where P is the parent and C is the child.

d. False Join Condition Discovery

Key discovery helps identify unique keys for each table. Inclusion discovery identifies foreign keys that are parts of a key for a table. There are many false foreign keys (e.g., custNum may go from 1 . . . N and productNum may go from 1 . . . M. A table T may have a column Num that goes from 1 . . . L where L<N and L<M). This ambiguity may be resolved using metadata matching. However, in the worst case, an inclusion dependency will be created between Cust and T on CustNum=Num and between Product and T on ProductNum=Num. These false dependencies are unlikely to yield any correlations and are mostly performance issues.

2. Source Data Object Construction

Once the parent-child relationships are identified, the processing represented by block 304 constructs source data objects as follows.

From a list of tables in the data source, the following relationships exist for each table:

-   -   Parent List—a list of tables that have an identifying foreign         key in this table     -   Peer List—a list of tables that have a partition relationship         with this table     -   Child List—a list of tables that have an identifying foreign key         that corresponds to a primary key in this table.

The peers are joined by first creating a view by doing a full outer join of all peer tables on their shared primary key. The view's parent and child lists are concatenations of the peer's parent and child lists. The peers are then removed from the table list, and the combined view is added to the table list. Subsequently, the processing represented by block 304 remove cycles. All tables that do not have any children or any parents are marked as “Clear”. All other tables are marked as “Potential Cycles.” The tables with Potential Cycles are ordered by the number of parents. The ordering starts with the tables having the least number of parents. For each table with Potential Cycles starting table S, the child links are followed and the cycles resolved using the Cycle Resolution Process, described below.

Source Data Objects (SDOs) are created by making each table that does not have any identifying foreign keys a source data object—it will be the “root” of the SDO. For each SDO, all the descendants of the root are added (children, children's children, etc.) If there are any cycles, the cycles are broken by creating two separate views on a table causing a cycle.

Each SDO can be “unfolded” into a single table by performing an outer join between every parent and its children. Subsequently, matching may be performed on the resulting flat table. In an alternate embodiment, the tables can be further subdivided into second or even third normal forms to perform matching on smaller relations.

a. Cycle Resolution Process

In one embodiment, a Cycle Resolution Process is performed according to the following process. Given a starting table S, a current table T and a list of processed tables P, for each table C in T's child list:

-   -   If C is marked as Clear—stop.     -   If C is the original starting table (S)—a cycle exists, and it         is resolved by creating another instance of S—a table S′.         Replace S with S′ in T's child list. Remove T from the parent         list of S and add it to S′ parent list.     -   If C is already in P stop—this cycle is not addressed here, it         will be addressed when C or T is processed.     -   Otherwise, add C to P, call Cycle Resolution Process with T=C At         the end of the process, mark S as Clean.

b. Manually Adjusting Source Data Objects

In one embodiment, a user can create new data objects or add tables to existing source data objects using a graphical user interface. In order to create a source data object, the user needs to specify a Data Object Name and a Root Table. In order to add a table to an existing Source Data Object, the user needs to specify the table being added, the parent for the table being added, and a Join Condition to join the table with its parent. Embodiments of a graphical user interface are described below with respect to FIGS. 7-9.

c. Universal Data Object Construction

Universal Data Objects span one or more data sources. Universal Data Objects are created using the Mapping Studio or by auto-mapping them to the Source Data Objects. Universal Data Object is a table tree similar to the Source Data Object, except it includes mappings for each table and each attribute to any number of Source Data Objects for any number of Data Sources.

i. Universal Data Object Definition

Universal Data Object (UDO) is a common data object representing different Source Data Objects in a single integrated structure. The data model of the UDO is a tree of tables related to each other through identifying reference relationship. A data object has the following properties:

-   -   Table Tree where each parent table has zero or more child         tables. There is a unique join condition to join each parent and         child table pair—typically an identifying primary-foreign key         condition.     -   Mapped Source Data Objects—the local data objects from different         data sources that have been mapped to this data object. For         each, there will be         -   Mapping for each table in the SDO including:             -   Binding condition             -   Attribute mappings

In addition, the following terms are used to describe a data object:

Root table is the root of the Table Tree. Root table does not have any parents

Nested Table—is any table in the Table Tree that is not a root table.

Leaf Table—a table in the Table Tree that does not have any children

Primary key—the primary key of the root table

Full Extended table—a left outer join of all the tables in a table tree achieved by starting with the root table and performing a left outer-join on all the child tables and then their child tables, etc. such that the parent is always the left table and the child is the right table. Note that some embodiments may use different joins such as an inner-join or a full outer-join.

Full Extended primary key—a combined key of every table in the data object

Attribute—a column of any table in a data object

Root attribute—a column of the root table

Nested attribute—a column of one of the nested tables

Extended table—a left-outer join of a branch leading to the child table that includes primary keys of the ancestors and the rows in the child table. Note that some embodiments may use different joins such as an inner-join or a full outer-join. For example, if the data object consists of a

-   -   Root table R with         -   Primary key column Pr         -   Children T1 and T2     -   T2 with         -   Primary key P2         -   Foreign key Pr         -   Join condition with R of R.Pr=T2.Pr         -   Child T21     -   T21 with         -   Primary key P21         -   Foreign key P2         -   Join condition T2.P2=T21.P2         -   Columns C1, . . . , Ci,             The extended T21 table would be generated as: select R.Pr,             T2.P2, T21.P21, T21.C1, . . . , T21.Ci from R, T2, T21 where             R.Pr*=T2.Pr and T2.P2*=T21.P2

Extended table key—a combined key of all ancestors of a table and the table. In the previous example, the extended table key would be Pr, P2, P21.

3. Mapping Discovery

Mapping Discovery involves the following processes: Schema mapping, Binding Discovery, Correlation Discovery, and Transform Function Discovery.

a. Schema Mapping

Data mapping is expensive. In one embodiment, in order to focus mapping on relevant columns, the processing represented by block 306 of FIG. 3 attempts to identify high probability correlated attributes using schema mapping. Schema mapping relies on several techniques:

-   -   Metadata index—a collection of words and synonyms used in table         and column names and descriptions.     -   Type compatibility matrix.     -   Exception list—a collection of words that may not provide         meaningful correlation. These include:         -   Frequently used names: names that do not present a high             confidence correlation without an additional qualifier             (e.g., “name”, “id”, “number”)         -   Description Ignore List: words that do not provide semantic             content (e.g., “the”, “a”, “in”, “on”, “for”).

i. Metadata Index

In one embodiment, a metadata index is the main schema-mapping tool. It is essentially a hash table of all the words encountered either as table names, column names or descriptions. Each entry in the table contains:

-   -   A list of UDO attributes that it corresponds to and has a         different relevance score for each attribute.     -   A list of synonyms (pointers to their index entries) that were         either pre-loaded or discovered. For each synonym, there is a         synonym relevance score that reflects how closely the synonym         matches a given word (e.g., “Number” and “Num” may have a         relevance score of 0.9,but “Number” and “Code” of 0.6)

Table 1,below, illustrates an embodiment of a metadata index:

TABLE 1 Entry Attributes (Score) Synonyms (Score) Num CustomerUDO.CustomerId (0.4) Number (0.9), Id (0.5), Count (0.8), Code (0.6), Nr (0.8), Identifier (0.5) Customer CustomerUDO.CustomerId (0.5), Client (0.9), Cust (0.9), CustomerUDO.CustomerAddress KUN (0.8) (0.4)

ii. Metadata Index Construction

Initially, the index is preloaded with a set of common term synonyms (e.g., “Num”, “Number”, “Id”, “Identifier”, “Code”, etc.). These entries are linked together with appropriate relevance scores and do not have any UDO attributes. In one embodiment, every time mapping is performed on data objects, the index gets populated as follows (Note, the coefficients, scores and multipliers are provided as examples. Different embodiments may use different coefficients, multipliers and scores): For each new attribute added to a UDO, add UDO attribute name to the index

-   -   Add column name to the index         -   If the name is a frequently used name from the exception             list (e.g., id), assign it relevance score of 0.5         -   If the name is not a frequently used name, split it into             words using delimiters. e.g., “Customer Name” gets split             into “Customer”, “Name”.             -   Each word gets added to the index with a score of                 1#words—e.g., 0.5 and 0.5. Supported delimiters include                 ‘ ’, ‘-’, ‘_’ and caps (e.g., CustomerName)     -   Break column description into words.         -   Remove the words in the Description Ignore List from the             list.         -   For each remaining word, add to the Metadata index with a             relevance=0.8/#words.     -   Add UDO object name to the index with relevance of 0.2/#words.     -   Add UDO object description to the index with relevance of         0.2/#words in the description.         If match an existing UDO attribute to an SDO attribute, set the         multiplier to 1 and update the index.         Given a multiplier, update the index as follows. Only add         entries to the index whose final relevance score >0.1).     -   Add SDO column name to the index with the relevance score of         multiplier/#words     -   Add SDO column description to the index with the relevance score         of 0.8*multiplier/#words     -   Add SDO table name to the index with the relevance score of         0.2*multiplier/#words     -   Add SDO table description to the index with the relevance score         of 0.2*multiplier/#words     -   If there are any foreign keys, add them as columns to the         metadata index (repeat step 2) with a multiplier of 0.8 if         identified through metadata or 0.6 if discovered.     -   If there is a user defined datatype for the column, add it to         the index with relevance of 0.5*multiplier/#words

iii. Schema Mapping Rules

In one embodiment, the following rules are included:

-   -   Word match rule     -   Type conversion rule     -   String Containment Rule—checks if string1 is contained in         string2         -   String Overlap Rule—checks if string1 and string2 have a             common substring

In one embodiment, users will be able to develop arbitrarily complex custom rules.

iv. Schema Matching Process

In one embodiment, a schema matching process using word match and type conversion rules is performed as follows:

-   -   Start with an empty Table Relevance List RT     -   For each source table.         -   Set relevance to 0.2         -   Apply Word Match Rule to table name—get back a list of             relevant attributes with relevancy score for each—add them             to RT         -   Apply Word Match Rule to table description—add resulting             attributes to RT     -   For each source column start with an empty Relevant Attribute         List RA         -   Copy RT (Table relevance list) to the Relevant Attribute             List RA         -   Apply Word Match Rule to column name             -   Set Relevance to 1             -   Add the results to RA             -   If the column has a user defined datatype, apply Word                 Match Rule to the datatype with relevance of 0.5         -   Apply Word Match Rule to column description with relevance             of 0.8     -   Each column now has a Relevant Attribute List RA         -   Sort list by relevance         -   Remove duplicate entries—if an Attribute is in the list more             than once, keep the entry with highest relevance score         -   For each relevant attribute in RA, perform type match using             type matching rule             -   If the type matching rule determines that the source                 column and the attribute in RA can be converted into                 each other without any loss of data or are identical,                 keep the score for the attribute as is             -   If the types can only be converted into each other with                 potential loss of data, multiply the relevance score by                 0.8             -   If the types cannot be converted into each other, remove                 the attribute from the list     -   Create a target oriented relevance list TRL such that every         target attribute mentioned in RL, gets it own list of relevant         source attributes         -   For each column SC that has a relevant attribute list RA             -   For each target attribute TC in RA                 -   Add SC to TC's TRL with the relevance score in RA.

b. Binding Condition Discovery

Once a Relevance list is created, the processing represented by block 308 of FIG. 3 discovers a binding condition between the UDO and an SDO. To simplify the description, this section describes an embodiment of the discovery of the binding condition between a source table and a target table. The described embodiment can be easily extended to the tables of a UDO and SDO or can be applied to any part of SDO or UDO sub-tree by flattening that sub-tree using an outer join technique described above.

A binding condition is a Boolean expression between the columns of the source table and the column of the target table that exclusively matches a row or a set of rows in the source table with a row or a set of rows in the target table. For example, given a source table S and a target table T, binding condition S.customerid=T.clientnum will match a row that represents company XYZ as a customer in S with a corresponding row that represents company XYZ as a customer in T. We refer to these corresponding rows of Source and Target tables as being bound.

Note that the match has to be exclusive—in other words, a row SR that represents company XYZ in the source can only match rows in the target TR that represent company XYZ and TR can only match SR. The binding condition does not have to be one row to one row. It can be one row to many rows, many rows to one row or many rows to many rows as long as every row in the source row set SRS is exclusively bound to the rows in the target row set TRS and every row in TRS is exclusively bound to the rows in SRS.

Multiple binding conditions are possible between the same tables (e.g., S.custname=T.clientname may be a binding condition as can S.customerid=T.clientnum). Percentage of bound rows helps identify the best binding condition. However, multiple binding conditions are possible. In fact, sometimes it is possible to get “false” binding conditions. For example, a customer id can be assigned independently as an integer in two disparate systems such that customer id 99 on one system is for customer X, while 99 on another system is for customer Y. A binding condition relating customer ids across these systems would be a false binding condition.

In order to identify false binding conditions, a correlation discovery process is used to identify correlations across systems. False binding conditions are unlikely to have any correlations, while true binding conditions will have multiple correlations. Thus the higher the number of correlation and the stronger those correlations are, the stronger is the binding condition.

Binding conditions are usually based on equality as illustrated in the following process. However, they can be any Boolean expression that can be applied to source and target tables to identify rows that are uniquely bound to each other.

i. Equality Based Binding Condition Discovery (EBCD1) Process

In one embodiment, the processing represented by block 308 of FIG. 3 performs an Equality Based Binding Condition Discovery (EBCD1) Process. The goal of the EBCD1 is that given a source table S and target table T, discover Boolean expression B that exclusively binds rows of S to rows of T.

Because of dirty data or domain mismatch (e.g., source has data for NY, while target for all of the United States), the binding may not be perfect. The following thresholds may be used to help identify meaningful matches:

-   -   Overlap Threshold—% of rows that must be matches for a         source/target column pair to be considered a potential binding         condition. In one embodiment, the     -   Overlap threshold is about 80%.     -   Combination Threshold—% of rows where two predicates occur         together to be considered a combination.

An embodiment of the EBCD1 process 400 is described below with respect to FIG. 4. At block 402, the process 400 creates a source column index table SCIT of all values in S. Each row of the column index table will contain a value Value, a column number ColNum and a count of how many times the value occurred in that column RowCount.

At block 404, the process 400 creates a target column index table TCIT of all values in T. Each row of the column index table will contain a value, a column number and a count of how many times the value occurred in that column.

At block 406, the process 400 sets NumSourceRows to the number of rows in S and NumTargetRows to the number of rows in T.

At block 408, the process 400 creates a Column Match Table CMT with columns: SourceCol—the column number of the source column, TargetCol—the column number of the target column, SourceHits—number of source rows that match, TargetHits—number of target rows that match, according to the following process:

-   -   For each unique row Srow in SCIT (a unique source column number,         value combination)         -   For each unique row Trow in TCIT (a unique target column             number, value combination)         -   If Srow.Value=Trow.Value, add Srow.RowCount to             -   CMT[SourceCol][TargetCol].SourceHits and Trow.RowCount                 to             -   CMT[SourceCol][TargetCol].TargetHits

At block 410, the process 400 moves high probability binding condition pairs into Predicate table with columns SourceCol and TargetCol, according to the following process:

-   -   For each Source column S         -   For each target column T             -   If CMT[S][T].SourceHits>numSourceRows*MatchThreshold and             -   CMT[S][T].TargetHits>numTargetRows*MatchThreshold, add S                 and T to the Predicate Table, setting SourceCol to S and                 TargetCol to T. In one embodiment, MatchThreshold is                 80%.             -   Assign a unique number to each predicate (e.g.,                 PredicateNum)         -   Store Predicates table in a relational database.

At block 412, the process 400 constructs binding conditions. At this point, there is a set of potential predicates. Some of these may be legitimate and some may be false binding conditions. We would like to identify combinations of predicates that generate more powerful binding conditions than individual predicates. The processing represented by block 412 of FIG. 4 is described in greater detail below with respect to FIG. 5.

Referring to FIG. 5, at block 502, the Construct Binding Condition process 500 builds a Source Row Index Table (SRIT) with columns Value, ColNum and RowNum, according to the following process:

-   -   Make a list of all source columns in Predicates Table:     -   PredSourceCol1 . . . PredSourceColN     -   Select values for those columns (select PredSourceCol1, . . . ,     -   PredSourceColN from S)     -   For each row R         -   For each column C             -   Add a row to SRIT where Value=the value of C, ColNum=the                 column number of C and RowNum=row number of R     -   Store SRIT in a relational database.

At block 504, the process 500 builds a Target Row Index Table (TRIT) with columns Value, ColNum and RowNum, according to the following process:

-   -   Make a list of all Target columns in Predicates Table:     -   PredTargetCol1 . . . PredTargetColN     -   Select values for those columns (select PredTargetCol1, . . . ,     -   PredTargetColN from S)     -   For each row R         -   For each column C             -   Add a row to TRIT where Value=the value of C, ColNum=the                 column number of C and RowNum=row number of R     -   Store TRIT in a relational database.

At block 506, the process 500 creates a RowMatchTable (or view) that identifies which predicates occur on which rows. The process 500 executes the following query against a database containing SRIT, TRIT and Predicates tables:

-   -   Select Predicates.PredNum, SRIT.RowNum as SourceRow, TRIT.RowNum         as TargetRow from Predicates, SRIT, TRIT where         Predicates.SourceCol=SRIT.ColNum and         Predicates.TargetCol=TRIT.ColNum and SRIT.RowNum=SRIT.RowNum         The process 500 subsequently stores the resulting rows in         RowMatchTable(PredicateNum, SourceRow, TargetRow)

At block 508, the process 500 identifies predicates that have high co-occurrence—for each predicate combination, the process 500 counts how many times predicates occur in the same row, according to the following process:

-   -   Issue the following SQL query: select RMT1.PredicateNum as         Pred1,     -   RMT2.PredicateNum as Pred2, count (*) as RowCount from         RowMatchTable     -   RMT1, RowMatchTable RMT2 where RMT1.SourceRow=RMT2.SourceRow and         RMT1.TargetRow=RMT2.TargetRow group by RMT1.PredicateNum,         RMT2.PredicateNum     -   Load the rows where RowCount>NumRows*CombinationThreshold into         Predicate Combinations Table PCT     -   Eliminate duplicates from PCT by deleting all rows where         Pred1>Pred2

At block 510, the process 500 creates binding conditions by combining predicates with high co-occurrence, according to the following process:

-   -   Read rows from PCT ordered by Pred1. For each new value P1 of         Pred1         -   Add P1 to PredicateList         -   For every row R with Pred1=P1, get P2=value of Pred2             -   Add P2 to PredicateList         -   Generate every combination of Predicates in PredicateList             (e.g., if PredicateList contains predicates 3, 5,and 11,             generate ({3}, {5}, {11 }, {3, 5}, {3, 11}, {5, 11} and {3,             5, 11})         -   Add each unique new combinations to the             BindingConditionsList (i.e., do not add duplicates)

At block 512, the process 500 generates Binding Condition strings according to the following process:

-   -   For every combination C of predicates in BindingConditionsList         -   For each predicate P in C             -   Set SourceColName to the source column name for that                 predicate             -   Set TargetColName to the target column name for that                 predicate             -   Generate a predicate string of the form                 “<SourceColName>=<TargetColName>”         -   Add predicate to the BindingConditionString             -   If BindingConditionString is empty,                 BindingConditionString=PredicateString             -   If BindingConditionString is not empty,                 BindingConditionString=“<BindingConditionString>and                 <PredicateString>”         -   Add BindingConditionString to the list of binding conditions             for S and T.

Referring again to FIG. 4, at block 414, the process 400 validates Binding Conditions using Correlations. For each Binding Condition, the process 400 performs a Correlation Discovery Process (CD1), described below. If CD1 does not return any correlations, the process 400 removes Binding Condition from the Binding Condition List. Otherwise, for each Correlation C discovered by CD1, the process 400 sets BindingConditionWeight=BindingConditionWeight+CorrelationWeight for C, and orders binding conditions in BindingConditionWeight order (i.e., the one with the most correlations wins).

ii. Correlation Discovery

The Correlation Discovery process (CD1) discovers correlation between Source and Target columns of bound tables. A set of source columns is said to be correlated to a set of target columns, if in every row of a source table, the value of a the source columns always corresponds to the same value of the target columns in a bound row of the target table. For example, Source.Region is correlated to Target.District if for every row of Source where Region=‘R1’, in the bound row of the Target, District=“East”. Since data may be dirty or out of sync, we do not expect the correlation to hold 100% and use a threshold to determine whether to accept a partial correlation.

Another way to describe this is if we join Source and Target on the binding condition, there will be a functional dependency between the correlated source and target columns. Note that it is not necessary to know how to transform the source columns into target columns, just that they correspond.

A transformation is a correlation where it is actually know how to generate the target column value from the bound source column values. For example, if Target.AreaCode=substring(Source.Phone, 1, 3) (first three characters of the Source.Phone field), there is a correlation between Target.AreaCode and Source.Phone and the transformation function is substring(Source.Phone, 1, 3). While a transformation is strictly a subset of correlation, in the rest of this description, correlations where the transformation function is not known are referred to as correlations and the correlations where the transformation function is known are referred to as transformations.

aa. Correlation Discovery (CD1) Process

The goal of the CD1 process is that given source table S, target table T and Binding condition B, discover all correlations between columns in S and columns in T. In one exemplary embodiment, the CD1 process obtains a correlation count for each Source column/Target column combination, eliminates unique columns, and creates correlations for each Source column/Target column combination where the correlation count is greater than a threshold.

In one embodiment, to help with the process, the following arrays and variables are used:

-   -   Int CorrelationCount[num source columns][num target         columns]—keeps correlation counters for each {S.Ci, T.Cx}         combination as CorrelationCount[i][x]     -   Int NonUniqueRowCount [num source columns]—keeps track of number         of rows that contain non-unique values for that column for each         source column     -   Int TotalRowCount—contains the number of bound row combinations.

In one embodiment, the following thresholds are also used:

-   -   UniqueColumnThreshold—% of non-unique rows that gives meaningful         correlation. In one embodiment, the UniqueColumnThreshold is         about 80%.     -   CorrelationThreshold—% of correlated rows that gives a         meaningful correlation.     -   In one embodiment, the CorrelationThreshold is about 80%.

For each source column S.Ci, target column T.Cx combination, the CD1 process summarizes the maximum count of a distinct value of how many times a value of T.Cx occurs for each value of S.Ci. For example, if S.Ci=5 occurs in 5 rows. In 3 of these rows T.Cx=‘abc’ and in 2 rows—‘xyz’; the max count of any value is 3 (for value ‘abc’), so the CD1 process adds 3 to the count of correlated rows between S.Ci and T.Cx.

In one embodiment, the process works as follows: for each source column S.Ci, the CD1 process issues the following SQL query:

-   -   Select S.Ci, T.C1, . . . , T.Cz from S, T where B order by Ci         The query will return a stream of values ordered by a value of         S.Ci. The CD1 process then performs the following process:

For each row, increment TotalRowCount For each unique value of S.Ci  If there is only 1 row for S.Ci - skip - go to the next value of S.Ci  If there are multiple rows   Increment NonUniqueRowCount[i] by number of rows   For each target column T.Cx    For each unique value U in T.Cx,     Set RowCount = count of how many times it     occurs for the same value of S.Ci     Add RowCount to a list of row counts     RowCountsList    Set MaxCount = Select the largest row count from    RowCountsList    Add MaxCount to CorrelationCount[i][x] Next, for each source column S.Ci, the CD1 process performs the following: Eliminate unique source columns   If NonUniqueRowCount[i] < TotalRowCount *   UniqueColumnThreshold, skip this column For each target column T.Cx   If CorrelationCount[1][X] > TotalRowCount *   CorrelationThreshold, create a correlation between S.Ci and T.Cx   with CorrelationWeight of TotalRowCount/   CorrelationCount[I][X].

c. Transformation Discovery

The processing represented at block 310 of FIG. 3 performs Transformation Discovery. The goal of Transformation Discovery is that given a binding condition (BINDING_CONDITION) and correlation between one or more source columns and a target column, discover the transformation function to generate the target column value from the source column values.

In one embodiment, different approaches can be applied for different types of columns. For example:

-   -   Numeric columns         -   Determine ratio         -   Determine difference         -   Convert to strings and apply string processes     -   Date, Time and Datetime columns         -   Determine interval (difference)     -   String columns         -   Apply PTD1 (described below) process to discover Positional             Transformations         -   Apply TTD1 process to discover Token Transformations         -   If numeric, convert to a number and apply numeric tests         -   If a date, time or datetime, convert to date and apply date             processes

ii. Positional Transformation Discovery Process 1 (PTD1)

To execute the Positional Transformation Discovery 1 (PTD1) process, the following arrays, variables and structures are used:

-   -   Int CharsetLen—number of characters in the character set. A         charset mapping table may be used to only represent meaningful         (e.g., printable) characters thereby minimizing the memory size         requirements. In such instances, CharsetLen would be the length         of the charset mapping table and instead of using the integer         representation of the character, characters position in the         charset mapping table is used.     -   Int CharMap[CharsetLen][MAX_COL_LEN]—for each character, this         array has a list of locations in the target column value where         that character occurs     -   Int CharMapCount[CharsetLen]—for each character, this array         contains a count of locations where that char occurs (i.e., the         length of location list in CharMap)     -   Int CharConstant [MAX_COL_LEN] [CharsetLen]—for each location,         count how many times each character occurs in each location     -   Char Constant [MAX_COL_LEN]—the constant character for each         location, ‘\0’ otherwise     -   Int         ForwardCharMatch[MAX_COL_LEN][MAX_NUM_COLUMNS][MAX_COL_LEN]—for         each location in target column value, keeps a count of how many         times there is a matching character for each location in the         source column value     -   Int         ReverseCharMatch[MAX_COL_LEN][MAX_NUM_COLUMNS][MAX_COL_LEN]—for         each location in target column value, keeps a count of how many         times there is a matching character for each reverse location in         the source column value. Reverse location is counted from the         end—e.g., 0 means the last character, 1 means the one before         last, etc.     -   Int matchThreshold—% of rows that need to have a match for a         location for it to be considered a match. Assumed to be >50%     -   Int constantThreshold—% of rows that need to have the same         character in a target location for it to be considered a         constant. Assumed to be >50%     -   Int variableThreshold—% of rows that need to have a fixed value         of target column for it to be considered variable length.         VariableThreshold should be <ConstantThreshold     -   Int NumberOfRows—number of rows in the target that have a         matching row in source tables given the binding condition     -   Structure Match—consists of the following fields         -   Type—one of Forward, Reverse, Constant         -   int column—source column         -   int location—source location         -   char constant     -   Match Matches[MAX_COL_LEN][MAX_COL_LEN]—array of matches that         has a list of matches for each target location     -   MatchCount[MAX_COL_LEN]—number of matches for each target         location in Matches array

The Positional Transformation Discovery 1 (PTD1) process 600 is described below with respect to FIG. 6.

At block 602, for each target column, the process 600 reads all correlated source columns in a single select (i.e., select sourcecolumn1, sourcecolumn2, . . . , targetcolumn from sourcetable1, sourcetable2, . . . , targettable where BINDING_CONDITION order by targetcolumn). For each row, the process performs the following:

-   -   a. Increment NumberOfRows     -   b. Get the value of the target column—TVALUE     -   c. SetCharConstant(TVALUE)     -   d. If TVALUE is not the same as previous TVALUE (PTVALUE)         -   i. Clear CharMap, CharMapCount         -   ii. SetCharMap(TVALUE)         -   iii. Reset PTVALUE=TVALUE     -   e. For each source column         -   i. Get value of source column UNTRIMMED_SVALUE         -   ii. Trim blanks from the end SVALUE=rtrim(UNTRIMMED_SVALUE,“             “)         -   iii. Get the column number SCOL         -   iv. For each character in SVALUE             -   1. Get char value: ScharValue             -   2. Get char location: SForwardCharLocation             -   3. Get reverse char location:                 SreverseCharLocation=Length(SVALUE)—SForwardCharLocation             -   4. Get count of entries in                 CharMap—TlocationCount=CharMapCount[ScharValue]             -   5. For each entry Entry in CharMap                 -   a. Get target location TcharLocation=CharMap[Entry]                 -   b. Increment forward match count                     ForwardCharMatch[TcharLocation][SCOL][SForwardCharLocation]++                 -   c. Increment reverse match count                     ReverseCharMatch[TcharLocation][SCOL][SReverseCharLocation]++

At block 604, the process 600 identifies constants according to the following process:

-   -   a. For each location ConstantLocation in CharConstants         -   i. Set Constant[ConstantLocation]=‘\0’—to indicate there is             no constant         -   ii. Set LocationCount=0         -   iii. For each character ConstantCharacter             -   1. Get the count ConstantCount of times character                 ConstantCharacter was in location ConstantLocation in                 target values             -   2. Set LocationCount=LocationCount+ConstantCount             -   3. If ConstantCount>ConstantThreshold*NumberOfRows                 -   a. Create a Match record M                 -    i. M.Type=Constant                 -    ii. M.Constant=ConstantCharacter                 -   b. Add M to Matches                 -    i. count=MatchCount[ConstantLocation]                 -    ii. MatchCount[ConstantLocation]=count+1                 -    iii. Matches[ConstantLocation][count]=M         -   iv. If LocationCount<ConstantThreshold—we have reached the             point where we will not find any more constants because we             do not have enough values to overcome the threshold             -   1. If LocationCount>VariableConstantThreshold—that means                 we have a variable length column and cannot do                 positional matching. Stop PTD1             -   2. Else if LocationCount<VariableConstantThreshold, the                 values that are longer then LocationCount are too few to                 worry about. We should fix                 TargetColumnLength=ConstantLocation             -   3. Stop constant identification

At block 606, for each target location TLOCATION, the process 600 finds the best match according to the following process:

-   -   b. For each source column SCOL         -   i. For each source location SLOCATION             -   1. get                 ForwardMatchCount=ForwardCharMatch[TLOCATION][SCOL][SLOCATION]             -   2. if ForwardMatchCount>matchThreshold                 -   a. Create a Match record M                 -    i. M.Type=Forward                 -    ii. M.Col=SCOL                 -    iii. M.Location=SLOCATION                 -   b. Add M to Matches                 -    i. count=MatchCount[TLOCATION]                 -    ii. MatchCount[TLOCATION]=count+1                 -    iii. Matches[TLOCATION][count]=M             -   3. get                 ReverseMatchCount=ReverseCharMatch[TLOCATION][SCOL][SLOCATION]             -   4. if ReverseMatchCount>matchThreshold                 -   a. Create a Match record M                 -    i. M.Type=Reverse                 -    ii. M.Col=SCOL                 -    iii. M.Location=SLOCATION                 -   b. Add M to Matches                 -    i. count=MatchCount[TLOCATION]                 -    ii. MatchCount[TLOCATION]=count+1                 -    iii. Matches[TLOCATION][count]=M

At block 608, the process 600 generates functions according to the following process:

-   -   c. If MatchCount[TLOCATION] is 0 for any TLOCATION=0.         TargetColumnLength         -   i. STOP—we could not discover any positional transformations     -   d. For each combination COMBINATION of matches (e.g., if         TargetColumnLength=2 and MatchCount[]=2 and MatchCount[1]=3, we         will have 6 combinations: {Match[0][0], Match[1][0]},         {Match[0][0], Match[1][1]}, . . . }. COMBINATION is array of         Match records         -   i. Start with FUNCTION=Empty string         -   ii. Convert consecutive forward char matches into substring             functions             -   1. if there are 1 or more Matches in locations Li=L1 . .                 . LN such that COMBINATION[Li].Type=Forward and                 COMBINATION[Li].Col=COMBINATION[Li+1].Col and                 COMBINATION[Li].Location=COMBINATION[Li+1].Location−1                 -   a. Create a substring function                     SUBSTRING=substring(ColName[Col], L1, LN-L1+1)                 -   b. Add substring to function:                     FUNCTION=FUNCTION+SUBSTRING         -   iii. Convert consecutive constants into constant strings             -   1. If there are 1 or more Constants in locations Li=L1 .                 . . LN such that COMBINATION[Li].Type=Constant                 -   a. Construct CONSTANT_STRING                 -    i. Set CONSTANT_STRING[0]=‘\”                 -    ii. For each Li in L1 . . . LN, set                     CONSTANT_STRING[Li-L1+1]=COMBINATION[Li].ConstatString                 -    iii. Set CONSTANT_STRING[L1-Li+2]=‘\”                 -   b. Add substring to function:                     FUNCTION=FUNCTION+CONSTANT_STRING         -   iv. Convert consecutive reverse char matches into substring             functions             -   1. if there are 1 or more Matches in locations Li=L1 . .                 . LN such that COMBINATION[Li].Type=Reverse and                 COMBINATION[Li].Col=COMBINATION[Li+1].Col and                 COMBINATION[Li].Location=COMBINATION[Li+1].Location+1                 -   a. Create a substring function                     SUBSTRING=substring(rtrim(ColName[Col], “ “),                     length(rtrim(ColName[Col]), “ “)—LN+1,LN-L1+1)                 -   b. Add substring to function:                     FUNCTION=FUNCTION+SUBSTRING

iii. Token Transformation Discovery (TTD1) Algorithm

Token Transformation Discovery Algorithm breaks values into tokens based on separator character set (SCS). In one embodiment, the token separator characters included: space, tab, newline, dash, forward slash, backward slash, comma, period, parenthesis, angle brackets, square brackets and figure brackets. A value is broken up into tokens as follows:

-   -   1. Start with Value V, empty Token List TL, empty Separator List         SL, empty current Token T=null and empty current separator         S=null     -   2. For each character C in value V,         -   a. if C is in not in SCS             -   i. if the current token T is empty (null)                 -   1. copy current separator S to the separator list                 -   2.set S=null                 -   3.create a new token T             -   ii. add C to the current token T         -   b. if C is in SCS             -   i. if current separator S is empty (null)                 -   1. if current token T is not empty, copy it to the                     token list                 -   2. set T=null                 -   3. create a new Separator S             -   ii. add C to S

Once the values are tokenized, apply Positional Transformation Discovery Algorithm (PTD1) to the tokens and to the separators where character locations are local to the tokens or the separator rather than entire strings.

iv. Helper Processes

The helper processes, SetCharMap(VALUE) and SetCharConstant(VALUE) referenced above with respect to the PTD1 process, are now described in greater detail.

The SetCharMap(VALUE) process performs the following:

-   Given a string value VALUE, populate a CharMap array -   For each character in VALUE     -   1. Get the character         -   a. Set charLocation=CharLocation—location of the character             in the value         -   b. Set charValue=VALUE[CharLocation]—the character in the             CharLocation in VALUE         -   c. For example, if VALUE=‘Fred’, the first character would             have CharLocation=0,CharValue=‘F’, the second character             would have CharLocation=1 and CharValue=‘r’     -   2. Get the number of entries for that character in CharMap         -   a. MapCount=CharMapCount[CharValue]     -   3. Add char location to CharMap         -   a. CharMap[CharValue][MapCount]=CharLocation     -   4. Increment char count         -   a. CharMapCount[CharValue]=MapCount+1

The SetCharConstant(VALUE) process performs the following:

-   Given a string value VALUE, populate CharConstant array -   For each character in VALUE,     -   1. Get the character         -   a. Set charLocation=CharLocation—location of the character             in the value         -   b. Set charValue=VALUE[CharLocation]—the character in the             CharLocation in VALUE         -   c. For example, if VALUE=‘Fred’, the first character would             have CharLocation=0,CharValue=‘F’, the second character             would have CharLocation=1 and CharValue=‘r’     -   2. Increment count in CharConstant array         -   a. CharConstant [CharLocation]             [CharValue]=CharConstant[CharLocation][CharValue]+1             Note, the SetCharConstant(VALUE) process should be performed             in conjunction with SetCharMap process, so we only go             through the characters once.

FIGS. 7A, 7B and 7C illustrate embodiments of a graphical user interface of the present invention. Referring to FIG. 7A, a main window 700 includes several subwindows. Subwindow 702 includes two tabbed views. A Source tab view 704 displays the columns of a current Source table which is being analyzed. A Source Tree tab 706 displays a Source Tree, from which a user may select a Source table to analyze.

Subwindow 708 displays current mapping parameters. A mapping query defined by the parameters in 708 transforms Source tables into Target tables. A Binding field 710 displays the current Binding Condition (e.g. Source.Id=Target.Id). The Binding Condition “binds” (i.e. relates) instances of source and target on Natural Key. A Target Column pulldown menu 712 allows a user to select a Target column from a Target table, which is mapped (or transformed) to a Source column as indicated in the Column Mapping Field 714.

Source Data subwindow 716 displays the data from the current Source table. Target Data subwindow 720 displays the data from a Target table. A Query Results subwindow 718 displays the results of the query based on the mapping parameters specified in Subwindow 708.

Subwindow 722 displays the success for a particular mapping between the Source table and the Column table. This provides a user with readily available statistics for Binding Conditions, in order to facilitate the user's understanding of the data and schema. Column 724 displays the mapping (or transformations) based on the Binding Condition 710.

Column 726 displays Row Hits as both a percentage and a fractional representation for each column. Row Hits describes the proportion of Source rows that had the same values as corresponding Target rows for the particular Binding Condition, i.e. (#rows that match/#rows in a table). For example, in the example illustrated in FIG. 7A, the Binding Condition Source.Id=Target.Id results in a 100% or 5/5 correlation between the rows of the Source.Id column and the rows of the Target.Id column. For Source.Name and Source.Dept, there is a 0% or 0/0 correlation with the Target table based on the Binding Condition 710. This is because although the Binding Condition 710 is based on a Primary Key of the Source table (e.g. Source.Id), the Binding Condition 710 does not include a Global Id. For Source.Territory, there is only a 60% or 3/5 correlation. In other words, for the Binding Condition Source.Id=Target.Id, only in three instances did Source.Territory=Target.Territory. Row Hits provides a user with a quick sampling of the success for a particular mapping. For example, in the example illustrated in FIG. 7A, the results in the Row Hits column 726 quickly inform a user that there were no matches based on the Binding Condition 710.

Column 728 displays Row Misses as both a percentage and a fractional representation for each column. Row Misses describes the proportion of Source rows that did not have the same values as corresponding Target rows for the particular binding Condition, i.e. (#rows that did not match/#rows in a table).

Column 730 displays Value Hits as both a percentage and a fractional representation for each column. Value Hits describes the proportion of unique matching Source and Target values to the number of unique values, i.e. (#unique values that match/#unique values). For example, for Source.Id, there were five matches between unique values, and a total of five unique values, hence 100% or 5/5 Value Hits. However, for Source.Territory, there was only one unique match, and a total of two unique values (e.g. Atlantic and West Coast). Thus there was a Value Hits score of 50% or 1/2.

Column 732 displays Value Misses as both a percentage and a fractional representation for each column. Value Misses describes the proportion of unique non-matching Source and Target values to the number of unique values, i.e. (#unique values that do match/#unique values).

FIG. 7B illustrates another embodiment of the user interface of FIG. 7A. In the sample of FIG. 7B, the Binding Condition 710 is set on natural keys, Source.Name=Target.Name and Source.Dept=Target.Dept. Additionally, the Target Column 712 is set to the Territory column of the Target Data 720, and is mapped to the Source.Territory column of the Source Data 716 as indicated in the Column Mapping Field 714. The results shown in Subwindow 722 indicate that there are matches for Name, Dept and Territory columns, and validate the appropriateness of the mapping defined in Subwindow 708.

FIG. 7C illustrates another embodiment of the user interface of FIG. 7A. In FIG. 7C, a focus function is illustrated. A focus function allows a user to investigate the results of a particular mapping. In one embodiment, a user may focus on Source Row to show corresponding Mapping Query Results Row and Target Row. In another embodiment, a user may focus on a Target Row to show corresponding Mapping Query Results Row and Source Row. For example, when a user selects a particular row 721 from Subwindow 720 (focus row), this row is highlighted and the source data 717 which is bound to the driver row 721 is displayed in the Source Data 716, and the query results 719 based on the bound source data 717 is displayed in the Query Results subwindow 718. The focus function allows a user to easily identify why there are no matches for a particular mapping, thus increasing the efficiency of determining appropriate mapping parameters.

The particular methods and processes of embodiments of the invention are described herein in terms of computer software with reference to a series of flow charts. The methods constitute computer programs made up of computer-executable instructions illustrated as blocks (acts). Describing the methods by reference to a flow diagram enables one skilled in the art to develop such programs including such instructions to carry out the methods on suitably configured computers (the processor of the computer executing the instructions from computer-readable media, including memory). The computer-executable instructions may be written in a computer programming language or may be embodied in firmware logic. If written in a programming language conforming to a recognized standard, such instructions can be executed on a variety of hardware platforms and for interface to a variety of operating systems. In addition, the present invention is not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the invention as described herein. Furthermore, it is common in the art to speak of software, in one form or another (e.g., program, procedure, process, application, module, logic . . . ), as taking an action or causing a result. Such expressions are merely a shorthand way of saying that execution of the software by a computer causes the processor of the computer to perform an action or produce a result. It will be appreciated that more or fewer processes may be incorporated into the methods described without departing from the scope of the invention and that no particular order is implied by the arrangement of blocks shown and described herein.

FIG. 8 is an illustration of one embodiment of an example computer system 800 on which embodiments of the present invention may be implemented. In one embodiment, computer system 800 is a conventional server computer system. Computer system 800 includes a processor 802 coupled to a bus 806. Memory 804, storage 812, non-volatile storage 805, display controller 808, input/output controller 816 and typically a modem or network interface 814 are also coupled to bus 806. The computer system 800 interfaces to external systems through the modem or network interface 814. This interface 814 may be an analog modem, Integrated Services Digital Network (ISDN) modem, cable modem, Digital Subscriber Line (DSL) modem, a T-1 line interface, a T-3 line interface, token ring interface, satellite transmission interface, or other interfaces for coupling a computer system to other computer systems. A carrier wave signal 823 is received/transmitted by modem or network interface 814 to communicate with computer system 800. In the embodiment illustrated in FIG. 1, carrier waive signal 823 is used to interface computer system 800 with a computer network 824, such as a local area network (LAN), wide area network (WAN), or the Internet. In one embodiment, computer network 824 is further coupled to a remote computer (not shown), such that computer system 800 and the remote computer can communicate.

Processor 802 may be a conventional microprocessor including, but not limited to, an Intel Corporation (trademark) x86,Pentium (trademark), or Itanium (trademark) family microprocessor, a Motorola (trademark) family microprocessor, or the like. Memory 804 may include, but not limited to, Dynamic Random Access Memory (DRAM), Static Random Access Memory (SRAM), Synchronized Dynamic Random Access Memory (SDRAM), Rambus (trademark) Dynamic Random Access Memory (RDRAM), or the like. Display controller 808 controls in a conventional manner a display 810, which in one embodiment may be a cathode ray tube (CRT), a liquid crystal display (LCD), and active matrix display or the like. An input/output device 818 coupled to input/output controller 816 may be a keyboard, disk drive, printer, scanner and other input and output devices, including a mouse, trackball, trackpad, joystick, or other pointing device.

The computer system 800 also includes non-volatile memory 805 on which firmware and/or data may be stored. Non-volatile memory devices include, but are not limited to Read-Only Memory (ROM), Flash memory, Erasable Programmable Read Only Memory (EPROM), Electronically Erasable Programmable Read Only Memory (EEPROM), or the like.

Storage 812 in one embodiment may be a magnetic hard disk, an optical disk, or another form of storage for large amounts of data. Some data may be written by a direct memory access process into memory 804 during execution of software in computer system 800. It is appreciated that software may reside in storage 812, memory 804, non-volatile storage 805 or may be transmitted or received via modem or network interface 814.

For the purposes of the specification, a machine-readable medium includes any mechanism that provides (i.e., stores and/or transmits) information in a form readable or accessible by a machine (e.g., a computer, network device, personal digital assistant, manufacturing tool, any device with a set of one or more processors, etc.). For example, a machine-readable medium includes, but is not limited to, recordable/non-recordable media (e.g., a read only memory (ROM), a random access memory (RAM), a magnetic disk storage media, an optical storage media, a flash memory device, etc.). In addition, a machine-readable medium can include propagated signals such as electrical, optical, acoustical or other form of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.).

It will be appreciated that computer system 800 is one example of many possible computer systems that have different architectures. For example, computer systems that utilize the Microsoft (trademark) Windows operating system in combination with Intel microprocessors often have multiple buses, one of which may be considered a peripheral bus. Network computers may also be considered as computer systems that may be used with the present invention. Network computers may not include a hard disk or other mass storage, and the executable programs are loaded from a wired or wireless network connection into memory 804 for execution by processor 802. In addition, handheld or palmtop computers, which are sometimes referred to as personal digital assistants (PDAs), may also be considered as computer systems that may be used with the present invention. As with network computers, handheld computers may not include a hard disk or other mass storage, and the executable programs are loaded from a wired or wireless network connection into memory 804 for execution by processor 802. A typical computer system will usually include at least a processor 802, memory 804, and a bus 806 coupling memory 804 to processor 802.

It will also be appreciated that in one embodiment, computer system 800 is controlled by operating system software that includes a file management system, such as a disk operating system, which is part of the operating system software. For example, one embodiment of the present invention utilizes Microsoft (trademark) Windows as the operating system for computer system 800. In other embodiments, other operating systems that may also be used with computer system 800 include, but are not limited to, the Apple Macintosh (trademark) operating system, the Linux (trademark) operating system, the Microsoft (trademark) Windows CE operating system, the Unix (trademark) operating system, the 3Com Palm (trademark) operating system, or the like.

The above description of illustrated embodiments of the invention, including what is described in the Abstract, is not intended to be exhaustive or to limit the invention to the precise forms disclosed. While specific embodiments of, and examples for, the invention are described herein for illustrative purposes, various equivalent modifications are possible within the scope of the invention, as those skilled in the relevant art will recognize. These modifications can be made to the invention in light of the above detailed description. The terms used in the following claims should not be construed to limit the invention to the specific embodiments disclosed in the specification and the claims. Rather, the scope of the invention is to be determined by the following claims, which are to be construed in accordance with established doctrines of claim interpretation. 

What is claimed is:
 1. A method for generating a mapping suitable for analyzing data in a first data source and a second data source, for identifying semantics and relationships between the first data source and the second data source, the method comprising: determining a binding condition between portions of data in the first data source and the second data source, wherein determining the binding condition comprises: creating a first column index table for the first data source; creating a second column index table for the second data source; creating an overlap column table from the first and second column index tables to identify potential binding conditions; constructing binding conditions from the potential binding conditions; and validating the binding conditions using the correlations; using the binding condition to determine correlations between portions of data in the first data source and the second data source; and using the binding condition and the correlations to generate the mapping between portions of data in the first data source and the second data source.
 2. The method of claim 1, wherein constructing the binding conditions comprises: building a first row index table for the first data source; building a second row index table for the second data source; using the first and second row index tables to create a row match table to identify the potential binding conditions having a high co-occurrence; combining the potential binding conditions having a high co-occurrence; and generating binding condition strings from the combined potential binding conditions.
 3. The method of claim 1, wherein the correlations are determined by a correlation determining process comprising: for each combination of a first and second data source column, identifying a maximum count of correlated rows between the first and second data source columns.
 4. The method of claim 1, further comprising determining a filter for the binding condition.
 5. The method of claim 1, further comprising determining a filter for the mapping.
 6. The method of claim 1, further comprising: determining a join condition; and using the join condition to generate a first data object for the first data source.
 7. The method of claim 1, further comprising performing schema matching between the first data object and a second data object of the second data source.
 8. The method of claim 7, wherein performing schema matching comprises constructing a metadata index including relevance scores.
 9. The method of claim 8, wherein the relevance scores are determined using a multiplier.
 10. The method of claim 1, wherein determining the mapping comprises: for each second data source column, reading correlated first data source columns; identifying constants; for each column in the second data source, finding a best match; and generating the mapping based on the best matches.
 11. A system comprising: a processing unit coupled to a memory through a bus; and a process for generating a mapping suitable for analyzing data in a first data source and a second data source, for identifying semantics and relationships between the first data source and the second data source, the method comprising: determining a binding condition between portions of data in the first data source and the second data source, wherein determining the binding condition comprises: creating a first column index table for the first data source; creating a second column index table for the second data source; creating an overlap column table from the first and second column index tables to identify potential binding conditions; constructing binding conditions from the potential binding conditions; and validating the binding conditions using the correlations; using the binding condition to determine correlations between portions of data in the first data source and the second data source; and using the binding condition and the correlations to generate the mapping between portions of data in the first data source and the second data source.
 12. The system of claim 11, wherein constructing the binding conditions comprises: building a first row index table for the first data source; building a second row index table for the second data source; using the first and second row index tables to create a row match table to identify the potential binding conditions having a high co-occurrence; combining the potential binding conditions having a high co-occurrence; and generating binding condition strings from the combined potential binding conditions.
 13. The system of claim 11, wherein the correlations are determined by a correlation determining process comprising: for each combination of a first and second data source column, identifying a maximum count of correlated rows between the first and second data source columns.
 14. The system of claim 11, further comprising determining a filter for the binding condition.
 15. The system of claim 11, further comprising determining a filter for the mapping.
 16. The system of claim 11, further comprising: determining a join condition; and using the join condition to generate a first data object for the first data source.
 17. The system of claim 11, further comprising performing schema matching between the first data object and a second data object of the second data source.
 18. The system of claim 17, wherein performing schema matching comprises constructing a metadata index including relevance scores.
 19. The system of claim 18, wherein the relevance scores are determined using a multiplier.
 20. The system of claim 11, wherein determining the mapping comprises: for each second data source column, reading correlated first data source columns; identifying constants; for each column in the second data source, finding a best match; and generating the mapping based on the best matches.
 21. A machine-readable medium having instructions to cause a machine to perform a machine-implemented method for generating a mapping suitable for analyzing data in a first data source and a second data source, for identifying semantics and relationships between the first data source and the second data source, the method comprising: determining a binding condition between portions of data in the first data source and the second data source, wherein determining the binding condition comprises: creating a first column index table for the first data source; creating a second column index table for the second data source; creating an overlap column table from the first and second column index tables to identify potential binding conditions; constructing binding conditions from the potential binding conditions; and validating the binding conditions using the correlations; using the binding condition to determine correlations between portions of data in the first data source and the second data source; and using the binding condition and the correlations to generate the mapping between portions of data in the first data source and the second data source.
 22. The machine-readable medium of claim 21, wherein constructing the binding conditions comprises: building a first row index table for the first data source; building a second row index table for the second data source; using the first and second row index tables to create a row match table to identify the potential binding conditions having a high co-occurrence; combining the potential binding conditions having a high co-occurrence; and generating binding condition strings from the combined potential binding conditions.
 23. The machine-readable medium of claim 21, wherein the correlations are determined by a correlation determining process comprising: for each combination of a first and second data source column, identifying a maximum count of correlated rows between the first and second data source columns. 